//
const as =(name:string)=>{
    console.log(`这是传入的参数${name}`)
}
as('99')


const objo={
    "a":123,
    'syhi':function(){
        setTimeout(()=>{
            console.log(this.a)
        },0)
    }
}
objo.syhi()


const a:number=100;
const b:string='字符串';
const c:boolean=true;
const e:void=undefined;
const f:null=null;
const g:undefined=undefined;
// const h:symbol=Symbol()  这是es6中的 所以会报错

const foo:object=function(){   }
const objs:{foo:number,bar:string}={foo:123,bar:'122'}

const arr1:Array<number>=[12,2,3,4]
const arr2:number[]=[123,4,4,3]
const arr3:[string,boolean,number]=['1',true,3]

const enum ProstStatus {
    draft,
    unpubi,
    pib
}

const post={
    status:ProstStatus.unpubi
}
console.log(post)

function func(a:number,b?:string, ...rest:number[]):string{  //...rest:number[]可以添加任意的长度
    return '字符串'
}
func(100,'122')
func(100)


const nums=[1,2,3,4]
const res=nums.find(i=>i>0)
const numbreRes=res as number //类型断言
// const numbreRes=<number>res  //类型断言


//接口  可以理解成约定和规范   （也就是约束对象的结构和对象属性的类型）

interface Post{
    title:string,
    name:string,
    submtitle?:string,  //可选成员
    readonly sumay:string //只读成员
}
function prinPost(post:Post){
    console.log(post.name)
    console.log(post.title)
}

prinPost({title:'wy',name:'hh',sumay:'212'})


//动态接口
interface cache{
    [kes:string]:string
}

const objsca:cache={}
objsca.foo='21'

class Person{
    public name:string  //public公共的属性修饰符
    private readonly age:number  //private私有属性修饰符  readonly是只读属性
    protected  gender:boolean  //protected受保护的属性修饰符 他和私有的区别是在于protected在子类的使用的
    constructor(name:string,age:number){
        this.name=name
        this.age=age
        this.gender=true
    }
    sayHi(msg:string):void{
        console.log(`i im ${this.name}  ${this.age}${msg}`)
    }
}

class ex extends Person{
    constructor(name:string,age:number){
        super(name,age)
        console.log(name,age,this.gender)
    }
}
const toms=new Person('王耀',14)
const esPerson=new ex('xiaoming',19)
// console.log(toms.name)
//console.log(toms.age) //被私有化的属性 只能在类的内部使用


//类也可以定义接口 一个功能最好定义一个接口然后组合使用 关键字implements
interface runs{
    run(dis:string):void
}

interface eats{
    eat(foo:string):void
}
class Person2 implements runs,eats {
    eat(foo:string):void{}
    run(dis:string):void{}
}

class Zoo implements runs,eats{
    eat(foo:string):void{}
    run(dis:string):void{}
}

//抽象类  必须由子类继承它 才能new 并且只是一个范围行的类所以用子类把它分的更细  关键字是 abstract
abstract class Animal{
    eat(foo:string):void{
        console.log('只是吃东西')
    }
    abstract run(dis:string):void
}

class zilei extends Animal{
    run(dis:string):void{
        console.log('我会跑步')
    }
}


// 泛型 函数 对象 类 我们首先不去定义它的类型 等我调用的时候传入一个类型 好处就是代码的复用性

function createNumber<T>(length:number,value:T):T[]{
    const arr= Array<T>(length).fill(value)
    return arr
}
const ress=createNumber<number>(3,100);
console.log(ress)